הנדסה-לאחור: שרשרת העלייה של Windows 7 חלק שני - VBR

Size: px

Start display at page:

Download "הנדסה-לאחור: שרשרת העלייה של Windows 7 חלק שני - VBR"

Daniel Gordon
5 years ago
Views:

הנדסה-לאחור: שרשרת העלייה של Windows 7 חלק שני - VBR מאת 0x3d5157636b525761 רקע בחלק הקודם דיברנו על ה- MBR, על הטעינה שלו על ידי ה- BIOS ועל כל הפעולות שהוא ביצע והכין לפני העברת האחריות ל- VBR.

במהלך המדריך אני אעבוד על Windows 7 SP1, x64 ולמעשה אמשיך מהמצב בו הפסקנו לפני כן. הערת צד: כל ניסוי שהקורא מחליט לבצע כתוצאה מקריאת מאמר זה - על אחריותו בלבד!

1 הנדסה-לאחור: שרשרת העלייה של Windows 7 חלק שני - VBR מאת 0x3d b רקע בחלק הקודם דיברנו על ה- MBR, על הטעינה שלו על ידי ה- BIOS ועל כל הפעולות שהוא ביצע והכין לפני העברת האחריות ל- VBR. בחלק זה נתמקד ב- VBR. ה- VBR )קיצור של )Volume Boot Record הוא הסקטור הראשון של המחיצה הלוגית. כאמור, הוא נטען על ידי ה- MBR, שהוא הסקטור הראשון של הדיסק הפיזי שעלה. במהלך המדריך אני אעבוד על Windows 7 SP1, x64 ולמעשה אמשיך מהמצב בו הפסקנו לפני כן. הערת צד: כל ניסוי שהקורא מחליט לבצע כתוצאה מקריאת מאמר זה - על אחריותו בלבד! חשיפת ה- VBR בניגוד לקריאת הדיסק הפיזי,)PhysicalDrive0( המצב הרבה יותר קל. בהנחה שהכונן הראשי הוא C: ניתוח ראשוני עם IDA נפתח את הקובץ ב- IDA. כמקודם, IDA לא יודעת לנתח את הקובץ ישירות כי מדובר בקוד טהור ולא בפורמט מוגדר ולכן ננתח את הקובץ כקוד 16 ביט. כמובן, נבצע rebase לכתובת 7C00 )אליה נטען ה- VBR על ידי ה- MBR ( ונלחץ על C בהתחלה כדי לנתח כקוד. כמקודם, ה- VBR מסתיים ב- 0xAA55, כצפוי.

2 חלק א': ישר קופצים? הדבר הראשון שנראה זה קפיצה מעל אזור די גדול אל - 0x7C54 מדוע? יש תשובה טובה לכך - אנחנו כבר לא בארץ ה- MBR הכיפי - מדובר כאן במחיצה, ולכן היא צריכה להכיל מערכת קבצים! כל מערכת קבצים מתחילה ב- header כלשהו שמתאר פרמטרים שונים בה, וכמובן - Windows עובד על.NTFS מכאן, כדאי להכנס למדריך כלשהו - אני נכנסתי אל שמסביר יפה מאד איך ה- layout הבסיסי נראה. כמובן, לא ניכנס לכאן אל,NTFS אבל זה יספיק לענייננו. הערת צד: המונח BPB שמופיע בהמון מקומות נקרא גם,BIOS PARAMETER BLOCK והוא מתאר את מערכת הקבצים. הוא שומש באופן מסורתי ב- FAT12 עבור floppies ולאחר מכן ב- FAT32 FAT16, ועכשיו גם ב- NTFS. יש לציין שישנן "גרסאות" ל- BPB, כאשר כל גרסא מרחיבה את הקודמת לה. זה של NTFS גדול במיוחד, בגודל 0x54 בתים! לאחר שאנחנו מבינים מדוע קיימת קפיצה, אפשר לראות מה קורה לאחר מכן ב- 0x7C54. אפשר לראות שהעניינים נראים די דומים )לפחות בהתחלה( למה שהיה עם ה- MBR : 2

3 ניתוח: ב- SP. מכיוון 0x7C00 והשמת SS איפוס - בניית המחסנית: דומה מאד למה שהתבצע ב- MBR שהמחסנית גדלה לכיוון כתובות נמוכות, אנחנו במצב טוב. שינוי CS ו- DS ל- 0x07C0 : זה למעשה יתן לנו יכולת עבודה טובה וקלה: מעתה כל אוגר הוא פשוט זהה לטכניקה ששומשה ב- MBR. push-push-retf מבסיס התוכנית. הטכניקה של offset על 0x0E שומרים את DL )ה- Number.)Drive מי שפרסר כבר את NTFS יודע ש- 16 ביט שם מכילים reserved sectors )ת'כלס זה.)0 בשלב הבא מוודאים שה- OEM הוא NTFS )זה נמצא בבית השלישי במשך 8 בתים(, ומוודאים שניתן לבצע קריאות LBA )בדומה למה שהיה ב- MBR (. נקודה משעשעת: ראינו ב- MBR שיש תמיכה גם אם אין עבודה עם,LBA אבל כאן רואים ש- LBA הוא פיצ'ר חובה! לא מצאתי תיעוד לכך, אבל אני יכול לחשוב על שתי סיבות מרכזיות:.CHS שמאפשר VBR גם למערכות הפעלה ישנות יותר, עם יתאים תאימות לאחור: ה- MBR תמיכה במערכות הפעלה שונות: אין סיבה שה- MBR לא יטען VBR של לינוקס )EXT( למשל. בכל מקרה של כשלון קופצים אל.0x7C8A איך אני יודע שזוהי הדפסה של שגיאה? התשובה היא שצריך להתסכל קצת מה קורה: ב- 0x7C8A קופצים באופן בלתי-מותנה אל 0x7D6A ושם מבצעים קריאה פעמיים אל פונקציה שמדפיסה שגיאות,TTY( כמו שהיה ב- MBR ( ולאחר מכן מבצעת HLT וקפיצה אינסופית. הנה הקוד החל מ- 0x7D6A ועד הסוף: 3

4 את הודעות השגיאה אני יודע להסיק מתוך ה- 0x7D6A למשל: מכיוון ש- DS הוא 0x07C0 אז DS:1F8 הוא למעשה.0x7DF8 הבית שמופיע שם הוא,0x8C וניתן לראות שבתחילת הפונקציה PrintMessage שמים בתוך AH את הערך 1, מה שאומר שכל AX יהיה 0x018C ולכן SI יהיה גם ערך זה. כמובן שאנחנו בסגמנט 0x07C0 ולכן ES:SI הוא 0x7D8C ושם כתוב ב- ANSI את המשפט המעצבן A. disk read error occurred לכן, PrintMessage מצפה שאוגר AL יחזיק את ה- offset של ההודעה להדפסה, בעוד 0x7DF8 משמשת כטבלת offset -ים עבור הודעות השגיאה. חלק ב': ההכנות לקראת הטעינה הבאה! קדימה לחלק הבא: ניתוח: בקטע קוד זה קוראים ל- int13 )דיסק( עם פונקציה מספר 0x48. ניתן לקרוא תיעוד מלא ב- RBIL, אבל בכל מקרה מה שחשוב לדעת זה שמספר הכונן number( )drive נמצא ב- DL, הבאפר שיתמלא נמצא על DS:SI וגודלו בבתים נשמר ב- WORD הראשון שלו )זה ה- 0x1A.)Push נקודה עדינה: מדוע עושים SUB SP על 0x18? התשובה היא ש- SI יקבל את ערכו של.SP תזכורת חשובה: SP מצביע על ראש המחסנית, על הכתובת האחרונה שבשימוש.)inclusive( ה- PUSH לאחר ה- SUB דוחף את הגודל שעליו דיברנו, ולכן בסך הכל הורדנו את SP ב- 0x1A בתים )ישנם גדלים נוספים הנתמכים, זו הדרך שבה הפסיקה מבצעת.)versioning אגב, כל הסיפור עובד כי המחסנית גדלה לכיוון כתובות נמוכות -- אם לא, היינו צריכים לבצע push 0x1A לפני פעולת ה- SUB. 4

5 bytes per במבנה שחוזר ניתן לראות שזה בדיוק ה-.POP AX ואז מבצעים נשים לב שמנקים רק 0x18 :)0x1A הנה המבנה המלא )כאשר הוא בגודל.sector Offset (HEX) Description Size (bytes) 0x0000 Size of buffer (0x1A) 2 0x0002 Information flags 2 0x0004 Number of physical cylinders on drive 2 0x0008 Number of physical heads on drive 2 0x000C Number of physical sectors on drive 2 0x0010 Number of total sectors on drive 8 0x0018 Bytes per sector 2 אז למעשה מה שביצענו הוא לקרוא ל- GetDriveParams על,DL וממנו לשלוף את.Bytes per sector כמובן שיש צורך לבצע בדיקות שהקריאה הצליחה וכו', וזה בדיוק מה שיתבצע בהמשך הקוד: לאחר מכן, בהמשך ניתן לראות כמה הכנות ואז תחילת לולאה. אלו הן הכנות לטעינת,BOOTMGR ולמעשה לא מכילות המון לוגיקה. מייקרוסופט כתבו קוד יחסית גנרי, ולכן הוא מתייחס לנתונים מתוך ה-.BPB אף על פי כן, אנחנו נתייחס לנתונים האלה כקבועים: 5

6 יש כאן כמה דברים מעניינים שנזכור לשלב מאוחר יותר: ה- WORD בכתובת 0x7C0F מקבלת 0x20, שזה גודל סקטור חלקי 16. ניתן לראות כאן שמייקרוסופט עשו קוד גנרי AX( מכיל בשלב זה את גודל הסקטור( ולא סתם הציבו 0x20 במקום המתאים. מקבל את הערך.0x07C0 DX אוגר אוגר BX מאופס. אוגר CX מקבל גודל של 15 סקטורים, בהנחה שגודל סקטור הוא 512 )זה נכון לפי ה- BPB (. דווקא כאן משעשע לראות שהקוד לא גנרי בכלל: אם גודל סקטור ישתנה בעתיד, הקוד הזה יידפק. ה- DWORD בכתובת 0x7C11 )שנמצאת ב- BPB ( "הופך" למשתנה גלובאלי, והוא מקבל את הערך 1. הקוד לאחר מכן ישר קורא לפונקציה שנמצאת בכתובת, 0x7D1D אז החלק הבא ינתח אותה. חלק ג':,ExtendedRead שוב... הפעם נשתולל לגמרי ונעשה חלקים די גדולים )הוספתי הערות כמובן(: 6

ניתוח: תחילת הפונקציה מגבה את כל ה- registers General purpose וכן את DS ו- ES. אפשר לראות שבסוף הפונקציה יש POP -ים מתאימים. מכאן מתחילה לולאה שמשתמשת בכמה משתנים גלובאליים.

7 ניתוח: תחילת הפונקציה מגבה את כל ה- registers General purpose וכן את DS ו- ES. אפשר לראות שבסוף הפונקציה יש POP -ים מתאימים. מכאן מתחילה לולאה שמשתמשת בכמה משתנים גלובאליים. בכתובת 0x7C11 נשמר מספר, שבאיטרציה הראשונה הוא 1. אפשר לראות שהוא גדל כל פעם באחד )בכל איטרציה(. )0x800(. נשמר ערך שלא משתנה בין איטרציות 0x7C1C בכתובת מכיוון ששני הערכים מחוברים לתוך EAX )ומכיוון ש- EAX הופך למספר הבלוק בדיסק שממנו נבצע את הקריאה(, ניתן להסיק שהערך שגדל כל פעם באחד הוא block counter ואילו הערך השני הוא "כתובת בסיס". מכאן מתבצעת הכנת ה- buffer input עבור הקריאה )פונקציה 0x42, פסיקה 0x13(. עברנו במאמר על ה- MBR על פונקציה זו ועל המבנה של הבאפר בפירוט, ולכן לא אחזור עליו. כהרגלי, אפנה את הקורא המלומד אל RBIL ובו יש פירוט מלא. ADD SP אלא ממש ביצוע הפסיקה וניקוי הבאפר ממנה. משעשע לראות שהניקוי הוא לא סתם פקודות,POP כאשר ECX משמש כאוגר "זבל" ל- DWORD -ים סוררים. אם לסכם, קראנו בלוק יחיד מהדיסק שנלקח מתוך EAX )והוא נלקח מתוך משתנה שמתחיל ב- 0x32801 וגדל כל פעם באחד(. הערכים הישנים של ES ו- BX נשמר ב- DX ו- BX, בהתאמה. להזכירכם, אלו הם הרגיסטרים ששומשו לשמירת הבלוק שנקרא מתוך הדיסק. כעת, אנחנו מצפים לוידוא שהקריאה הצליחה ולהכנה לקראת האיטרציה הבאה, וכך אכן מתבצע: 7

8 ניתוח:.)CF כדי לוודא שהפסיקה הצליחה )אם היא נכשלה אז היא משנה את JB ביצוע הגדלה של ערך ES בערך שנמצא תחת.0x7C0F ערך זה יהיה 0x20, כפי שניתחנו לפני כן. הורדה של הערך תחת.0x7C16 ערך זה יסמן לנו את מספר האיטרציות לביצוע - כאשר הוא מגיע לאפס, הפונקציה מסתיימת. כמובן, בכל מקרה של שגיאה תודפסנה הודעות שגיאה ונגיע ללולאה אינסופית של HLT ו- JMP. ראינו דוגמא דומה בניתוח של ה- MBR. אם לסכם, פונקציה זו מבצעת קריאה סדרתית )block-by-block( של הדיסק. מספר הבלוקים נקבעים לפי המשתנים 0x7C11 ו- 0x7C1C, מספר האיטרציות נקבע לפי,0x7C16 ובאפר היעד יהיה.ES:BX חלק ד': יאללה ל- bootmgr! עכשיו יהיה מעניין להסתכל על הקוד שקרא לפונקציה שכעת ניתחנו. הפלא-ופלא, זה בדיוק קוד ההמשך שלנו: ניתוח: הערך של DX עולה כל פעם ב- 0x20 )זה גודל סקטור חלקי 16 שחישבנו לפני כן(. בהתחלה הוא היה,0x07C0 ולכן באיטרציה הראשונה הוא יקבל 0x07E0 וכן הלאה. לאחר מכן אנחנו מבינים ש- DX סתם היה אוגר ביניים, וכל מה שאמרתי עד כה היה עבור.ES נקודה עדינה: זה זמן טוב להיזכר ש- BX מאופס. מכיוון ש- ES:BX משמשים כבאפר שבו ייכתב המידע, בפועל המידע ייכתב לכתובות הפיזיות 0x7E00, 0x8000 וכן הלאה! לכן היה צורך לחלק את גודל הסקטור ב- 16, וכאן ניתן לראות כבר שהקוד שמתמלא ייכנס היישר אל.x7C000 נזכור גם ש- BX )ולמעשה, כל שאר האוגרים( לא מושפע מקריאה לפונקציה עקב השימוש ב- PUSHAD. ייחסנו חשיבות גדולה אל,0x7C16 והפונקציה ExtendedDiskRead מתייחסת אליו מאד ברצינות, אבל בפועל הוא תמיד יהיה 1 לכן קראתי לו בשם flag" "Iteration - משעשע לראות שמייקרוסופט כתבו פונקציית ExtendedRead גנרית מאד שתומכת במספר רב של איטרציות, אך בפועל קוראת לו כל פעם עם איטרציה אחת 8

9 לאחר מכן בודקים תמיכה ב- platform :Trusted ניתוח: קריאה ל- TCG_StatusCheck )על ידי,)AX=0xBB00 מחזירה ב- EAX את הערך 0 אם יש תמיכה. אם לא, ממשיכים הלאה. בדיקה ש- EBX מחזיק את ערך החזרה הנכון. אם לא, ממשיכים הלאה. בדיקה שהגרסא היא 1.02 ומעלה. אם לא, ממשיכים הלאה. הייתי רוצה שנזכור אם המשפט "אם לא, ממשיכים הלאה", שחזר אחרי עצמו 3 פעמים. אנחנו ננצל את המשפט הזה להערות הסיום. אם הכל טוב עד כה, נגיע ל- 0x7CEF. בבלוק זה תתבצע קריאה אל TCG_CompactHashLogExtendEvent ולאחר מכן יבוצע fallback אל.lblRunBootMgr הקריאה מתוארת באתר של Trusted Computing Group תחת: D0C3B9075B5AFF17/TCG_PCClientImplementation_1-21_1_00.pdf הנה הקוד שקורא לפונקציה זו: 9

10 ניתוח:,POPAD כדי להשפיע על כל האוגרים. נשים לב הקוד דוחף מלא ערכים למחסנית ואז מבצע שהאוגרים יוצאים בסדר הפוך. כל השדות מתוארים הן בקוד והן באתר של ה- TCG. ספציפית, השדות המאד מעניינים הם המצביע לבאפר שעליו עושים HASH )כתובת )07C0:01B8 וגודלו.)0xE70( לאחר מכן מגיעים אל סוף התכנית, :lblrunbootmgr כאן מתבצע,Zero filling אף על פי שלא ברור מדוע יש צורך במילוי הזיכרון באפסים ולכאורה ניתן להסתדר בלעדיו. בכל מקרה, לאחר מכן, מעבירים את השליטה אל הכתובת,0x7E7A שאליה נטען.BOOTMGR כאן למעשה נגמר הקוד הראשי של ה- VBR. את שתי הפונקציות )קריאה מהדיסק והדפסה( ניתחנו. נקודות מעניינות ותובנות יש לי חוב קטן: איך אני יודע שמדובר ב- bootmgr בכלל? ישנן כמה תשובות טובות, והכנתי אותן בסגנון פסח, כי זה הסתדר לי לא רע: 1. חכם - מה הוא אומר? דיבגתי ואכן ראיתי ש- bootmgr עולה. 2. רשע - מה הוא אומר? הרי קיימת בקוד הודעת השגיאה missing"."bootmgr is 3. תם - מה הוא אומר? שרשרת העלייה של Windows מתעדת שהרכיב הבא בתור הוא bootmgr ואני מאמין לתיעוד. 4. ושאינו יודע לשאול? כנראה שלא הגיע לחלק זה של המאמר בכל מקרה... 01

11 אני רוצה שניזכר בנקודה המעניינת על ה- TCG - שימו לב שמתבצעות מספר קריאות, אבל הן best-,effort כלומר, אם אין תמיכה - לא נורא. חלק גדול מה- bootkits עשו hooking על int 0x13 ועל ידי כך החזירו בלוקים שקריים מהדיסק, עם נתונים שלהם. ניתן בהחלט להמציא bootkit שיבצע hooking על הקריאות אל ה- TCG, מכיוון שאף על פי שהן נקראות - נראה שלשרשרת העלייה לא כל כך אכפת אם הן מצליחות או לא. יהיה מעניין כפרוייקט לעשות hooking על.int 0x1A סיכום המשכנו את תהליך העלייה של,Windows הפעם התמקדנו בחלק השני: ה- VBR. התעמקנו בנושאים הבאים: ה- BPB קריאות אל ה- TPM Extended Read מהדיסק עם bootmgr טעינת bootmgr העברת שליטה אל הוספתי נספח של הקוד השלם. הייתי מוסיף,IDB אבל גרסאות שונות של IDA לא תומכות בהכרח בכל IDB וגם נחמד שזה יגיע יחד עם המסמך. מדובר בקוד הסופי, כולל ההערות, כמובן. על המחבר,0x3d b עושה Reversing ופיתוח Low Level למחייתו. ניתן ליצור איתי קשר ב: 0x3d b525761@gmail.com 00

12 02 נספח א': הקוד המלא כולל הערות ; ; Input MD5 : C1C0E5D5E2701CBDA3FD4292CD32D6C2 ; Input CRC32 : 2A6D0660 ; ; File Name : vbr.bin ; Format : Binary file ; Base Address: 0000h Range: 0000h h Loaded length: 0200h.686p.mmx.model flat ; =========================================================================== ; Segment type: Pure code seg000 segment byte public 'CODE' use16 assume cs:seg000 ;org 7C00h assume es:nothing, ss:nothing, ds:nothing, fs:nothing, gs:nothing lblstart: ; DATA XREF: seg000:7c62o jmp short lblmain seg000:7c02 ; seg000:7c02 nop seg000:7c02 ; seg000:7c03 g_dwoemlo dd 'SFTN' ; DATA XREF: seg000:7c6ar seg000:7c03 ; OEM ID seg000:7c07 dd ' ' seg000:7c0b dw 200h ; Bytes per sector seg000:7c0d db 8 ; Sectors per cluster seg000:7c0e g_wreservedsectors dw 0 ; DATA XREF: seg000:lblstartparsingntfsw seg000:7c0e ; seg000:7c96r seg000:7c0e ; Reserved sectors seg000:7c10 db 0, 0, 0 ; 0 ; Zero seg000:7c13 dw 0 ; Unused seg000:7c15 db 0F8h ; ; Media descriptor seg000:7c16 dw 0 ; Zero seg000:7c18 dw 3Fh ; Sectors per track seg000:7c1a dw 0FFh ; Number of heads seg000:7c1c dd 32800h ; Hidden sectors seg000:7c20 dd 0 ; Unused seg000:7c24 dd h ; Unused seg000:7c28 dq 1866D7FFh ; Total sectors seg000:7c30 dq 0C0000h ; Logical cluster number for the file $MFT seg000:7c38 dq 2 ; Logical cluster number for the file $MFTMirr seg000:7c40 dd 0F6h ; Clusters per file record segment seg000:7c44 db 1 ; Clusters per index buffer seg000:7c45 db 0, 0, 0 ; 0 ; Unused seg000:7c48 dq 88B4B852B4B8448Ah ; Volume serial number seg000:7c50 dd 0 ; Checksum seg000:7c54 ; seg000:7c54 seg000:7c54 lblmain: ; CODE XREF: seg000:lblstartj seg000:7c54 cli seg000:7c55 ; seg000:7c55 ; Build stack seg000:7c55 ;

13 seg000:7c55 seg000:7c55 xor ax, ax seg000:7c57 mov ss, ax seg000:7c59 mov sp, 7C00h seg000:7c5c sti seg000:7c5d ; seg000:7c5d ; Make CS=DS=0x07C0 seg000:7c5d ; seg000:7c5d push 7C0h seg000:7c60 pop ds seg000:7c61 assume ds:nothing seg000:7c61 push ds seg000:7c62 push (offset lblstartparsingntfs - offset lblstart) seg000:7c65 retf seg000:7c66 seg000:7c66 lblstartparsingntfs: ; DATA XREF: seg000:7c62o seg000:7c66 mov ds:0eh, dl ; Save drive number in [0x0E] seg000:7c6a ; seg000:7c6a ; Make sure the OEM is "NTFS" seg000:7c6a ; seg000:7c6a cmp dword ptr ds:3, 'SFTN' seg000:7c73 jnz short lblprinterrorandhangcaller seg000:7c75 ; seg000:7c75 ; Check for LBA mode reading seg000:7c75 ; seg000:7c75 mov ah, 41h ; 'A' seg000:7c77 mov bx, 55AAh seg000:7c7a int 13h ; DISK - Check for INT 13h Extensions seg000:7c7a ; BX = 55AAh, DL = drive number seg000:7c7a ; Return: CF set if not supported seg000:7c7a ; AH = extensions version seg000:7c7a ; BX = AA55h seg000:7c7a ; CX = Interface support bit map seg000:7c7c jb short lblprinterrorandhangcaller seg000:7c7e cmp bx, 0AA55h seg000:7c82 jnz short lblprinterrorandhangcaller seg000:7c84 test cx, 1 seg000:7c88 jnz short lblgetdriveparams seg000:7c8a seg000:7c8a lblprinterrorandhangcaller: ; CODE XREF: seg000:7c73j seg000:7c8a ; seg000:7c7cj... seg000:7c8a jmp lblprinterrorandhang seg000:7c8d ; seg000:7c8d seg000:7c8d lblgetdriveparams: ; CODE XREF: seg000:7c88j seg000:7c8d push ds seg000:7c8e ; seg000:7c8e ; Make room for the buffer on the stack seg000:7c8e ; Size of buffer = 0x1A seg000:7c8e ; seg000:7c8e sub sp, 18h seg000:7c91 push 1Ah ; 0x1A because it's WORD more than 0x18 + the way PUSH works seg000:7c94 ; seg000:7c94 ; Function 48 (get drive paramters) seg000:7c94 ; DL = drive number seg000:7c94 ; DS:SI = buffer to fill seg000:7c94 ; seg000:7c94 mov ah, 48h ; 'H' seg000:7c96 mov dl, ds:0eh ; DL = Drive number from [0x0E] seg000:7c9a mov si, sp seg000:7c9c push ss seg000:7c9d pop ds 03

14 seg000:7c9e assume ds:nothing seg000:7c9e int 13h ; DISK - IBM/MS Extension - GET DRIVE PARAMETERS (DL - drive, DS:SI - buffer) seg000:7ca0 ; seg000:7ca0 ; Clear buffer from stack seg000:7ca0 ; seg000:7ca0 lahf seg000:7ca1 add sp, 18h seg000:7ca4 sahf seg000:7ca5 pop ax ; Bytes per sector seg000:7ca6 pop ds ; Restore DS seg000:7ca7 ; seg000:7ca7 ; Check for failures and mismatches: seg000:7ca7 ; 1. INT13 failure seg000:7ca7 ; 2. Bytes per sector failure seg000:7ca7 ; seg000:7ca7 jb short lblprinterrorandhangcaller seg000:7ca9 cmp ax, ds:0bh ; [0x0B] is exactly bytes per sector in the BPB seg000:7cad jnz short lblprinterrorandhangcaller seg000:7caf ; seg000:7caf ; Copy bytes per sector to 0x7C0F and shift seg000:7caf ; Shifting by 4 is just like division by 16 seg000:7caf ; This puts 0x20 in 0x7C0F seg000:7caf ; seg000:7caf mov ds:0fh, ax seg000:7cb2 shr word ptr ds:0fh, 4 seg000:7cb7 ; seg000:7cb7 ; Preparations for loading BOOTMGR seg000:7cb7 ; seg000:7cb7 push ds seg000:7cb8 pop dx ; DX = 0x07C0 seg000:7cb9 xor bx, bx seg000:7cbb mov cx, 2000h ; CX = 16 sectors seg000:7cbe sub cx, ax ; CX - AX = 15 sectors seg000:7cc0 inc dword ptr ds:11h ; [0x7C11] = 1 (was zero) seg000:7cc5 ; seg000:7cc5 ; Load BOOTMGR code seg000:7cc5 ; seg000:7cc5 seg000:7cc5 lblloadchunkfromdisk: ; CODE XREF: seg000:7cd4j seg000:7cc5 add dx, ds:0fh ; DX is increased by 0x20 (0x07E0, 0x0800, 0x0820,..., 0x9A0) seg000:7cc9 mov es, dx ; ES = DX seg000:7ccb inc word ptr ds:16h ; 0x7C16 = 1 = one iteration seg000:7ccf call ExtendedDiskRead seg000:7cd2 sub cx, ax ; 0x2000 initially, each time decreased by 0x200 seg000:7cd4 ja short lblloadchunkfromdisk seg000:7cd6 ; seg000:7cd6 ; TCG, if possible seg000:7cd6 ; seg000:7cd6 mov ax, 0BB00h seg000:7cd9 int 1Ah ; Trusted Computing Group call - TCG_StatusCheck seg000:7cd9 ; Return: EAX = 0 if supported seg000:7cd9 ; EBX = h ('TCPA') seg000:7cd9 ; CH:CL = TCG BIOS Version seg000:7cd9 ; EDX = BIOS TCG Feature Flags seg000:7cd9 ; ESI = Pointer to Event Log seg000:7cd9 ; seg000:7cdb and eax, eax seg000:7cde jnz short lblrunbootmgr ; Best-effort 04

15 seg000:7ce0 cmp ebx, 'APCT' seg000:7ce7 jnz short lblrunbootmgr ; Best-effort seg000:7ce9 cmp cx, 102h seg000:7ced jb short lblrunbootmgr ; Best-effort seg000:7cef ; seg000:7cef ; TCG_CompactHashLogExtendEvent seg000:7cef ; seg000:7cef push ss seg000:7cf0 push 0BB07h ; EAX = 0x0000BB07 seg000:7cf3 push ss seg000:7cf4 push 0E70h ; ECX = 0x00000E70 = length of buffer to be hashed seg000:7cf7 push ss seg000:7cf8 push 9 ; EDX = 0x = PCR index seg000:7cfb push ebx ; EBX seg000:7cfd push ebx ; Dummy ESP seg000:7cff push ebp ; EBP seg000:7d01 push ss seg000:7d02 push ss ; ESI = 0x = informative value to be placed into the event field seg000:7d03 push ss seg000:7d04 push 1B8h ; EDI = 0x000001B8 = offset of buffer to be hashed seg000:7d07 popad seg000:7d09 push cs seg000:7d0a pop es ; ES = CS = segment of buffer to be hashed seg000:7d0b int 1Ah ; Trusted Computing Group call - TCG_StatusCheck seg000:7d0b ; Return: EAX = 0 if supported seg000:7d0b ; EBX = h ('TCPA') seg000:7d0b ; CH:CL = TCG BIOS Version seg000:7d0b ; EDX = BIOS TCG Feature Flags seg000:7d0b ; ESI = Pointer to Event Log seg000:7d0b ; seg000:7d0d seg000:7d0d lblrunbootmgr: ; CODE XREF: seg000:7cdej seg000:7d0d ; seg000:7ce7j... seg000:7d0d xor ax, ax seg000:7d0f ; seg000:7d0f ; Zero filling seg000:7d0f ; seg000:7d0f mov di, 1028h seg000:7d12 mov cx, 0FD8h seg000:7d15 cld seg000:7d16 rep stosb seg000:7d18 ; seg000:7d18 ; Pass control to bootmgr seg000:7d18 ; seg000:7d18 jmp near ptr 7E7Ah seg000:7d1b ; seg000:7d1b nop seg000:7d1c nop seg000:7d1d seg000:7d1d ; =============== S U B R O U T I N E ======================================= seg000:7d1d seg000:7d1d seg000:7d1d ExtendedDiskRead proc near ; CODE XREF: seg000:7ccfp seg000:7d1d pushad ; All 32 bit registers are pushed seg000:7d1f push ds ; Backup DS and ES seg000:7d20 push es seg000:7d21 seg000:7d21 lblreadattempt: 05 ; CODE XREF: ExtendedDiskRead+46j

16 seg000:7d21 mov eax, ds:11h ; Loads the block counter seg000:7d25 add eax, ds:1ch ; Adds the base block number seg000:7d2a ; seg000:7d2a ; Prepare buffer for extended read operation seg000:7d2a ; seg000:7d2a push ds ; Save DS seg000:7d2b push large 0 ; Starting block number HI seg000:7d31 push eax ; Starting block number LO seg000:7d33 push es ; Transfer buffer HI seg000:7d34 push bx ; Transfer buffer LO seg000:7d35 push 1 ; Number of blocks to transfer seg000:7d38 push 10h ; Size = 0x10, reserved = 0 seg000:7d3b ; seg000:7d3b ; Prepare parameters for extended read seg000:7d3b ; seg000:7d3b mov ah, 42h ; 'B' ; Function #52 - extended read seg000:7d3d mov dl, ds:0eh ; Drive number seg000:7d41 push ss seg000:7d42 pop ds ; DS = 0 (because SS = 0) seg000:7d43 mov si, sp ; SI points to the buffer seg000:7d45 ; seg000:7d45 ; Perform the interrupt seg000:7d45 ; seg000:7d45 int 13h ; DISK - IBM/MS Extension - EXTENDED READ (DL - drive, DS:SI - disk address packet) seg000:7d47 ; seg000:7d47 ; Cleanups seg000:7d47 ; seg000:7d47 pop ecx ; 0x0110 seg000:7d49 pop bx ; Old BX seg000:7d4a pop dx ; Old ES seg000:7d4b pop ecx ; Old EAX seg000:7d4d pop ecx ; 0 seg000:7d4f pop ds ; Restore DS seg000:7d50 ; seg000:7d50 ; Validation seg000:7d50 ; seg000:7d50 jb lblprinterrorandhang seg000:7d54 ; seg000:7d54 ; Post iteration operations seg000:7d54 ; seg000:7d54 inc dword ptr ds:11h ; Increase block counter seg000:7d59 add dx, ds:0fh ; Increase buffer pointer seg000:7d5d mov es, dx seg000:7d5f dec word ptr ds:16h ; Decrease iteration flag seg000:7d63 jnz short lblreadattempt seg000:7d65 ; seg000:7d65 ; Restore registers and return seg000:7d65 ; seg000:7d65 pop es seg000:7d66 pop ds seg000:7d67 popad seg000:7d69 retn seg000:7d6a ; seg000:7d6a seg000:7d6a lblprinterrorandhang: ; CODE XREF: seg000:lblprinterrorandhangcallerj seg000:7d6a ; ExtendedDiskRead+33j seg000:7d6a mov al, ds:1f8h seg000:7d6d call PrintMessage seg000:7d70 mov al, ds:1fbh seg000:7d73 call PrintMessage seg000:7d76 06

17 seg000:7d76 lblhang: ; CODE XREF: seg000:7d77j seg000:7d76 hlt seg000:7d76 ExtendedDiskRead endp seg000:7d76 seg000:7d77 ; seg000:7d77 jmp short lblhang seg000:7d79 seg000:7d79 ; =============== S U B R O U T I N E ======================================= seg000:7d79 seg000:7d79 seg000:7d79 PrintMessage proc near ; CODE XREF: ExtendedDiskRead+50p seg000:7d79 ; ExtendedDiskRead+56p seg000:7d79 mov ah, 1 seg000:7d7b mov si, ax seg000:7d7d ; seg000:7d7d ; Handle the next character seg000:7d7d ; seg000:7d7d seg000:7d7d lblnextchar: ; CODE XREF: PrintMessage+10j seg000:7d7d lodsb seg000:7d7e cmp al, 0 seg000:7d80 jz short lblfinishprinting seg000:7d82 ; seg000:7d82 ; Perform TTY printing and handle the next character seg000:7d82 ; seg000:7d82 mov ah, 0Eh seg000:7d84 mov bx, 7 seg000:7d87 int 10h ; - VIDEO - WRITE CHARACTER AND ADVANCE CURSOR (TTY WRITE) seg000:7d87 ; AL = character, BH = display page (alpha modes) seg000:7d87 ; BL = foreground color (graphics modes) seg000:7d89 jmp short lblnextchar seg000:7d8b ; seg000:7d8b seg000:7d8b lblfinishprinting: ; CODE XREF: PrintMessage+7j seg000:7d8b retn seg000:7d8b PrintMessage endp seg000:7d8b seg000:7d8b ; seg000:7d8c aadiskreaderror db 0Dh,0Ah seg000:7d8c db 'A disk read error occurred',0 seg000:7da9 abootmgrismissi db 0Dh,0Ah seg000:7da9 db 'BOOTMGR is missing',0 seg000:7dbe abootmgriscompr db 0Dh,0Ah seg000:7dbe db 'BOOTMGR is compressed',0 seg000:7dd6 apressctrlaltde db 0Dh,0Ah seg000:7dd6 db 'Press Ctrl+Alt+Del to restart',0dh,0ah,0 seg000:7df8 db 8Ch seg000:7df9 db 0A9h ; _ seg000:7dfa db 0BEh ; _ seg000:7dfb db 0D6h ; _ seg000:7dfc db 0 seg000:7dfd db 0 seg000:7dfe db 55h ; U seg000:7dff db 0AAh ; seg000:7dff seg000 ends seg000:7dff seg000:7dff seg000:7dff end 07

ASP.Net MVC + Entity Framework Code First.

ASP.Net MVC + Entity Framework Code First 1 הקדמה בפרק הזה יוצג שימוש בFirst EntityFramework Code עבור ה use case הבאים : ASP.Net MVC ASP.Net Web API ASP.Net MVC + Scaffolding הערה : Framework Entity הוצג